﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using grupo2DEWStudio7i.Dominio;
using grupo2DEWStudio7i.Persistencia.ADO;
using grupo2DEWStudio7i.Persistencia;

namespace grupo2DEWStudio7i.Pruebas
{
    [TestFixture]
    public class TestClienteDAO
    {
        // Atributos a utilizar durante las pruebas
        private IClienteDAO clienteDAO = null;
        private int codigoGenerado = 0;

        [TestFixtureSetUp]
        public void PrepararPruebas()
        {
            // 1. Definimos la implementación del DAO a probar (ADO / NH / EF)
            clienteDAO = new ClienteDAO();
            // 2. Eliminamos todos los locales en BD antes de las pruebas
            foreach (Cliente cliente in clienteDAO.ListarTodos())
                clienteDAO.Eliminar(cliente);
            // 3. Creamos 2 locales para tenerlos disponibles en las pruebas
            clienteDAO.Crear(new Cliente() { Nombre = "Rock", Dni = "12345678", FecNac = "01/01/10", Clave = "123", Correo = "demo@demo.com" });
            clienteDAO.Crear(new Cliente() { Nombre = "ys", Dni = "12345678", FecNac = "01/01/10", Clave = "567", Correo = "samplles@demo.com" });
        }
        [Test]
        public void Test1_Crear()
        {
            // 1. Clase a probar: ClienteDAO
            Assert.IsNotNull(clienteDAO);
            // 2. Declaramos e instanciamos la entidad de dominio
            Cliente clienteACrear = new Cliente();
            clienteACrear.Nombre = "Jose Diaz";
            clienteACrear.Dni = "12345678";
            clienteACrear.FecNac = "01/02/2005";
            clienteACrear.Clave = "demo";
            clienteACrear.Correo = "jacg@live.com";
            // 3. Declaramos la entidad que contendrá el resultado
            Cliente clienteCreada = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                clienteCreada = clienteDAO.Crear(clienteACrear);
                codigoGenerado = clienteCreada.Codigo;
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(clienteCreada);
            // Probamos que el código generado sea mayor a 0
            Assert.Greater(clienteCreada.Codigo, 0);
            // Probamos que el nombre registrado es igual al solicitado con la entidad
            Assert.AreEqual(clienteCreada.Nombre, clienteACrear.Nombre);

        }
        [Test]
        public void Test2_Obtener()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(clienteDAO);
            // 2. Definimos los datos para la prueba
            int codigo = codigoGenerado;
            // 3. Declaramos la entidad que contendrá el resultado
            Cliente clienteObtenida = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                clienteObtenida = clienteDAO.Obtener(codigo);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(clienteObtenida);
            Assert.AreEqual(clienteObtenida.Codigo, codigo);
            Assert.IsNotNullOrEmpty(clienteObtenida.Nombre);
        }
        [Test]
        public void Test3_Modificar()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(clienteDAO);
            // 2. Declaramos e instanciamos la entidad de dominio
            Cliente clienteAModificar = clienteDAO.Obtener(codigoGenerado);

            clienteAModificar.Nombre = "Jose Diaza";
            clienteAModificar.Dni = "87654321";
            clienteAModificar.Correo = "jacg@live.com";
            clienteAModificar.Clave = "demo";
            clienteAModificar.FecNac = "01/02/2005";
            // 3. Declaramos la entidad que contendrá el resultado
            Cliente clienteModificada = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 4. Ejecutamos el método a probar
                clienteModificada = clienteDAO.Modificar(clienteAModificar);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(clienteModificada);
            // Probamos que el código generado sea mayor a 0
            Assert.AreEqual(clienteModificada.Codigo, codigoGenerado);
            // Probamos que el nombre registrado es igual al solicitado con la entidad
            Assert.AreEqual(clienteModificada.Nombre, clienteAModificar.Nombre);

        }
        [Test]
        public void Test4_Eliminar()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(clienteDAO);
            // 2. Definimos la entidad que contendrá el resultado
            Cliente clienteExistente = clienteDAO.Obtener(codigoGenerado);
            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 4. Ejecutamos el método a probar
                clienteDAO.Eliminar(clienteExistente);
            });
            // Probamos que la entidad ya no existe
            Assert.IsNull(clienteDAO.Obtener(codigoGenerado));
        }
        [Test]
        public void Test5_ListarTodos()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(clienteDAO);
            // 2. Declaramos la entidad que contendrá el resultado
            ICollection<Cliente> clientesEncontradas = null;
            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 4. Ejecutamos el método a probar
                clientesEncontradas = clienteDAO.ListarTodos();
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(clientesEncontradas);
            // Probamos que la cantidad de locales encontrados sea 2
            Assert.AreEqual(clientesEncontradas.Count, 2);
            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Cliente clienteEncontrada in clientesEncontradas)
            {
                Assert.IsNotNull(clienteEncontrada);
                Assert.IsInstanceOf(typeof(Cliente), clienteEncontrada);
            }
        }
        [Test]
        public void Test6_ListarXBusqueda()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(clienteDAO);
            // 2. Definimos los datos para la prueba
            string nombre = "oc"; // Rock *
            // 3. Declaramos la entidad que contendrá el resultado
            ICollection<Cliente> clientesEncontradas = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                clientesEncontradas = clienteDAO.ListarBusqueda(null, nombre, null, null, null, null);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(clientesEncontradas);
            // Probamos que la cantidad de locales encontrados sea 1
            Assert.AreEqual(clientesEncontradas.Count, 1);
            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Cliente clienteEncontrada in clientesEncontradas)
            {
                Assert.IsTrue(clienteEncontrada.Nombre.Contains(nombre));
            }
        }

    }
}